home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / Resources.p < prev    next >
Text File  |  1996-05-01  |  15KB  |  437 lines
  1. {
  2.      File:        Resources.p
  3.  
  4.      Contains:    Resource Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT Resources;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __RESOURCES__}
  28. {$SETC __RESOURCES__ := 1}
  29.  
  30. {$I+}
  31. {$SETC ResourcesIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __MIXEDMODE__}
  38. {$I MixedMode.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __FILES__}
  41. {$I Files.p}
  42. {$ENDC}
  43. {$IFC FOR_SYSTEM8_COOPERATIVE }
  44. {$IFC UNDEFINED __FILEMANAGERTYPES__}
  45. {$I FileManagerTypes.p}
  46. {$ENDC}
  47. {$ENDC}
  48.  
  49. {$PUSH}
  50. {$ALIGN MAC68K}
  51. {$LibExport+}
  52.  
  53. {
  54.     InitResources and RsrcZoneInit are no longer needed in Copland.
  55.  *    CFM provides the necessary run time initialization entry points.
  56. }
  57. {$IFC FOR_SYSTEM7_ONLY }
  58. FUNCTION InitResources: INTEGER;
  59.     {$IFC NOT GENERATINGCFM}
  60.     INLINE $A995;
  61.     {$ENDC}
  62. PROCEDURE RsrcZoneInit;
  63.     {$IFC NOT GENERATINGCFM}
  64.     INLINE $A996;
  65.     {$ENDC}
  66. {$ENDC}
  67. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  68.  
  69. CONST
  70.     resSysHeap                    = 64;                            { System or application heap? }
  71.     resPurgeable                = 32;                            { Purgeable resource? }
  72.     resLocked                    = 16;                            { Load it in locked? }
  73.     resProtected                = 8;                            { Protected? }
  74.     resPreload                    = 4;                            { Load in on OpenResFile? }
  75.     resChanged                    = 2;                            { Resource changed? }
  76.     mapReadOnly                    = 128;                            { Resource file read-only }
  77.     mapCompact                    = 64;                            { Compact resource file }
  78.     mapChanged                    = 32;                            { Write map out at update }
  79.     resSysRefBit                = 7;                            { reference to system/local reference }
  80.     resSysHeapBit                = 6;                            { In system/in application heap }
  81.     resPurgeableBit                = 5;                            { Purgeable/not purgeable }
  82.     resLockedBit                = 4;                            { Locked/not locked }
  83.     resProtectedBit                = 3;                            { Protected/not protected }
  84.     resPreloadBit                = 2;                            { Read in at OpenResource? }
  85.     resChangedBit                = 1;                            { Existing resource changed since last update }
  86.     mapReadOnlyBit                = 7;                            { is this file read-only? }
  87.     mapCompactBit                = 6;                            { Is a compact necessary? }
  88.     mapChangedBit                = 5;                            { Is it necessary to write map? }
  89.     kResFileNotOpened            = -1;                            { ref num return as error when opening a resource file }
  90.     kSystemResFile                = 0;                            { this is the default ref num to the system file }
  91.  
  92.  
  93. TYPE
  94.     ResErrProcPtr = Register68kProcPtr;  { PROCEDURE ResErr(thErr: OSErr); }
  95.  
  96.     ResErrUPP = UniversalProcPtr;
  97.  
  98. CONST
  99.     uppResErrProcInfo = $00001002;
  100.  
  101. FUNCTION NewResErrProc(userRoutine: ResErrProcPtr): ResErrUPP;
  102.     {$IFC NOT GENERATINGCFM }
  103.     INLINE $2E9F;
  104.     {$ENDC}
  105.  
  106. PROCEDURE CallResErrProc(thErr: OSErr; userRoutine: ResErrUPP);
  107.     {$IFC NOT GENERATINGCFM}
  108.     {To be implemented:  Glue to move parameters into registers.}
  109.     {$ENDC}
  110. {$ENDC}
  111. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  112. PROCEDURE CloseResFile(refNum: INTEGER);
  113.     {$IFC NOT GENERATINGCFM}
  114.     INLINE $A99A;
  115.     {$ENDC}
  116. FUNCTION ResError: INTEGER;
  117.     {$IFC NOT GENERATINGCFM}
  118.     INLINE $A9AF;
  119.     {$ENDC}
  120. FUNCTION CurResFile: INTEGER;
  121.     {$IFC NOT GENERATINGCFM}
  122.     INLINE $A994;
  123.     {$ENDC}
  124. FUNCTION HomeResFile(theResource: Handle): INTEGER;
  125.     {$IFC NOT GENERATINGCFM}
  126.     INLINE $A9A4;
  127.     {$ENDC}
  128. PROCEDURE CreateResFile(fileName: Str255);
  129.     {$IFC NOT GENERATINGCFM}
  130.     INLINE $A9B1;
  131.     {$ENDC}
  132. FUNCTION OpenResFile(fileName: Str255): INTEGER;
  133.     {$IFC NOT GENERATINGCFM}
  134.     INLINE $A997;
  135.     {$ENDC}
  136. PROCEDURE UseResFile(refNum: INTEGER);
  137.     {$IFC NOT GENERATINGCFM}
  138.     INLINE $A998;
  139.     {$ENDC}
  140. FUNCTION CountTypes: INTEGER;
  141.     {$IFC NOT GENERATINGCFM}
  142.     INLINE $A99E;
  143.     {$ENDC}
  144. FUNCTION Count1Types: INTEGER;
  145.     {$IFC NOT GENERATINGCFM}
  146.     INLINE $A81C;
  147.     {$ENDC}
  148. PROCEDURE GetIndType(VAR theType: ResType; index: INTEGER);
  149.     {$IFC NOT GENERATINGCFM}
  150.     INLINE $A99F;
  151.     {$ENDC}
  152. PROCEDURE Get1IndType(VAR theType: ResType; index: INTEGER);
  153.     {$IFC NOT GENERATINGCFM}
  154.     INLINE $A80F;
  155.     {$ENDC}
  156. PROCEDURE SetResLoad(load: BOOLEAN);
  157.     {$IFC NOT GENERATINGCFM}
  158.     INLINE $A99B;
  159.     {$ENDC}
  160. FUNCTION CountResources(theType: ResType): INTEGER;
  161.     {$IFC NOT GENERATINGCFM}
  162.     INLINE $A99C;
  163.     {$ENDC}
  164. FUNCTION Count1Resources(theType: ResType): INTEGER;
  165.     {$IFC NOT GENERATINGCFM}
  166.     INLINE $A80D;
  167.     {$ENDC}
  168. FUNCTION GetIndResource(theType: ResType; index: INTEGER): Handle;
  169.     {$IFC NOT GENERATINGCFM}
  170.     INLINE $A99D;
  171.     {$ENDC}
  172. FUNCTION Get1IndResource(theType: ResType; index: INTEGER): Handle;
  173.     {$IFC NOT GENERATINGCFM}
  174.     INLINE $A80E;
  175.     {$ENDC}
  176. FUNCTION GetResource(theType: ResType; theID: INTEGER): Handle;
  177.     {$IFC NOT GENERATINGCFM}
  178.     INLINE $A9A0;
  179.     {$ENDC}
  180. FUNCTION Get1Resource(theType: ResType; theID: INTEGER): Handle;
  181.     {$IFC NOT GENERATINGCFM}
  182.     INLINE $A81F;
  183.     {$ENDC}
  184. FUNCTION GetNamedResource(theType: ResType; name: Str255): Handle;
  185.     {$IFC NOT GENERATINGCFM}
  186.     INLINE $A9A1;
  187.     {$ENDC}
  188. FUNCTION Get1NamedResource(theType: ResType; name: Str255): Handle;
  189.     {$IFC NOT GENERATINGCFM}
  190.     INLINE $A820;
  191.     {$ENDC}
  192. PROCEDURE LoadResource(theResource: Handle);
  193.     {$IFC NOT GENERATINGCFM}
  194.     INLINE $A9A2;
  195.     {$ENDC}
  196. PROCEDURE ReleaseResource(theResource: Handle);
  197.     {$IFC NOT GENERATINGCFM}
  198.     INLINE $A9A3;
  199.     {$ENDC}
  200. PROCEDURE DetachResource(theResource: Handle);
  201.     {$IFC NOT GENERATINGCFM}
  202.     INLINE $A992;
  203.     {$ENDC}
  204. FUNCTION UniqueID(theType: ResType): INTEGER;
  205.     {$IFC NOT GENERATINGCFM}
  206.     INLINE $A9C1;
  207.     {$ENDC}
  208. FUNCTION Unique1ID(theType: ResType): INTEGER;
  209.     {$IFC NOT GENERATINGCFM}
  210.     INLINE $A810;
  211.     {$ENDC}
  212. FUNCTION GetResAttrs(theResource: Handle): INTEGER;
  213.     {$IFC NOT GENERATINGCFM}
  214.     INLINE $A9A6;
  215.     {$ENDC}
  216. PROCEDURE GetResInfo(theResource: Handle; VAR theID: INTEGER; VAR theType: ResType; VAR name: Str255);
  217.     {$IFC NOT GENERATINGCFM}
  218.     INLINE $A9A8;
  219.     {$ENDC}
  220. PROCEDURE SetResInfo(theResource: Handle; theID: INTEGER; name: Str255);
  221.     {$IFC NOT GENERATINGCFM}
  222.     INLINE $A9A9;
  223.     {$ENDC}
  224. PROCEDURE AddResource(theData: Handle; theType: ResType; theID: INTEGER; name: Str255);
  225.     {$IFC NOT GENERATINGCFM}
  226.     INLINE $A9AB;
  227.     {$ENDC}
  228. FUNCTION GetResourceSizeOnDisk(theResource: Handle): LONGINT;
  229.     {$IFC NOT GENERATINGCFM}
  230.     INLINE $A9A5;
  231.     {$ENDC}
  232. FUNCTION GetMaxResourceSize(theResource: Handle): LONGINT;
  233.     {$IFC NOT GENERATINGCFM}
  234.     INLINE $A821;
  235.     {$ENDC}
  236. FUNCTION RsrcMapEntry(theResource: Handle): LONGINT;
  237.     {$IFC NOT GENERATINGCFM}
  238.     INLINE $A9C5;
  239.     {$ENDC}
  240. PROCEDURE SetResAttrs(theResource: Handle; attrs: INTEGER);
  241.     {$IFC NOT GENERATINGCFM}
  242.     INLINE $A9A7;
  243.     {$ENDC}
  244. PROCEDURE ChangedResource(theResource: Handle);
  245.     {$IFC NOT GENERATINGCFM}
  246.     INLINE $A9AA;
  247.     {$ENDC}
  248. PROCEDURE RemoveResource(theResource: Handle);
  249.     {$IFC NOT GENERATINGCFM}
  250.     INLINE $A9AD;
  251.     {$ENDC}
  252. PROCEDURE UpdateResFile(refNum: INTEGER);
  253.     {$IFC NOT GENERATINGCFM}
  254.     INLINE $A999;
  255.     {$ENDC}
  256. PROCEDURE WriteResource(theResource: Handle);
  257.     {$IFC NOT GENERATINGCFM}
  258.     INLINE $A9B0;
  259.     {$ENDC}
  260. PROCEDURE SetResPurge(install: BOOLEAN);
  261.     {$IFC NOT GENERATINGCFM}
  262.     INLINE $A993;
  263.     {$ENDC}
  264. FUNCTION GetResFileAttrs(refNum: INTEGER): INTEGER;
  265.     {$IFC NOT GENERATINGCFM}
  266.     INLINE $A9F6;
  267.     {$ENDC}
  268. PROCEDURE SetResFileAttrs(refNum: INTEGER; attrs: INTEGER);
  269.     {$IFC NOT GENERATINGCFM}
  270.     INLINE $A9F7;
  271.     {$ENDC}
  272. FUNCTION OpenRFPerm(fileName: Str255; vRefNum: INTEGER; permission: SInt8): INTEGER;
  273.     {$IFC NOT GENERATINGCFM}
  274.     INLINE $A9C4;
  275.     {$ENDC}
  276. FUNCTION RGetResource(theType: ResType; theID: INTEGER): Handle;
  277.     {$IFC NOT GENERATINGCFM}
  278.     INLINE $A80C;
  279.     {$ENDC}
  280. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255; permission: SInt8): INTEGER;
  281.     {$IFC NOT GENERATINGCFM}
  282.     INLINE $A81A;
  283.     {$ENDC}
  284. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255);
  285.     {$IFC NOT GENERATINGCFM}
  286.     INLINE $A81B;
  287.     {$ENDC}
  288. FUNCTION FSpOpenResFile({CONST}VAR spec: FSSpec; permission: SignedByte): INTEGER;
  289.     {$IFC NOT GENERATINGCFM}
  290.     INLINE $700D, $AA52;
  291.     {$ENDC}
  292. PROCEDURE FSpCreateResFile({CONST}VAR spec: FSSpec; creator: OSType; fileType: OSType; scriptTag: ScriptCode);
  293.     {$IFC NOT GENERATINGCFM}
  294.     INLINE $700E, $AA52;
  295.     {$ENDC}
  296. PROCEDURE ReadPartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  297.     {$IFC NOT GENERATINGCFM}
  298.     INLINE $7001, $A822;
  299.     {$ENDC}
  300. PROCEDURE WritePartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  301.     {$IFC NOT GENERATINGCFM}
  302.     INLINE $7002, $A822;
  303.     {$ENDC}
  304. PROCEDURE SetResourceSize(theResource: Handle; newSize: LONGINT);
  305.     {$IFC NOT GENERATINGCFM}
  306.     INLINE $7003, $A822;
  307.     {$ENDC}
  308. FUNCTION GetNextFOND(fondHandle: Handle): Handle;
  309.     {$IFC NOT GENERATINGCFM}
  310.     INLINE $700A, $A822;
  311.     {$ENDC}
  312. {
  313.  Use TempInsertROMMap to force the ROM resource map to be
  314.    inserted into the chain in front of the system. Note that
  315.    this call is only temporary - the modified resource chain
  316.    is only used for the next call to the resource manager.
  317.    See IM IV 19 for more information. 
  318. }
  319. PROCEDURE TempInsertROMMap(tempResLoad: BOOLEAN);
  320. {$IFC OLDROUTINENAMES }
  321. FUNCTION SizeResource(theResource: Handle): LONGINT;
  322.     {$IFC NOT GENERATINGCFM}
  323.     INLINE $A9A5;
  324.     {$ENDC}
  325. FUNCTION MaxSizeRsrc(theResource: Handle): LONGINT;
  326.     {$IFC NOT GENERATINGCFM}
  327.     INLINE $A821;
  328.     {$ENDC}
  329. PROCEDURE RmveResource(theResource: Handle);
  330.     {$IFC NOT GENERATINGCFM}
  331.     INLINE $A9AD;
  332.     {$ENDC}
  333. {$ENDC}
  334. {$ENDC}
  335.  
  336. TYPE
  337.     ResFileRefNum                        = INTEGER;
  338.     ResID                                = INTEGER;
  339.     ResAttributes                        = INTEGER;
  340.     ResFileAttributes                    = INTEGER;
  341.  
  342. CONST
  343.     kResFileReadOnlyPermission    = 100;
  344.     kResFileReadWriteExclusivePermission = 101;
  345.  
  346.  
  347. TYPE
  348.     ResFilePermissions                    = UInt32;
  349. {$IFC FOR_SYSTEM8_COOPERATIVE }
  350. FUNCTION RMRemoveResFileFromSearchPath(refNum: ResFileRefNum): OSStatus; C;
  351. FUNCTION RMAddResFileToSearchPath(refNum: ResFileRefNum): OSStatus; C;
  352. {
  353.  *    New API returning OSStatus, rolling in low mem, and fixing
  354.  *    some sins of the past.
  355.  *
  356. }
  357. FUNCTION RMCreateResFile(fsFolderObjectRef: FSObjectRef; fsName: FSName; creator: OSType; theType: OSType): OSStatus; C;
  358. FUNCTION RMOpenResFile(specification: FSObjectRef; permissions: ResFilePermissions; resLoad: BOOLEAN; VAR refNum: ResFileRefNum): OSStatus; C;
  359. FUNCTION RMCloseResFile(refNum: ResFileRefNum): OSStatus; C;
  360. FUNCTION RMUpdateResFile(refNum: ResFileRefNum): OSStatus; C;
  361. FUNCTION RMUseResFile(refNum: ResFileRefNum): OSStatus; C;
  362. FUNCTION RMCurResFile(VAR refNum: ResFileRefNum): OSStatus; C;
  363. {
  364.  *    We don't want to support resource file attributes other then
  365.  *    the readOnly bit.  Access to the readOnly bit is now gained
  366.  *    through the calls RMSetResFileReadOnlyState and RMGetResFileReadOnlyState.
  367.  *
  368.  *    So, for now, we will not support RMGetResFileAttrs and RMSetResFileAttrs.
  369.  *
  370.  *  OSStatus RMGetResFileAttrs(ResFileRefNum refNum, ResFileAttributes * attributes);
  371.  *  OSStatus RMSetResFileAttrs(ResFileRefNum refNum, ResFileAttributes attributes);
  372. }
  373. FUNCTION RMHomeResFile(theResource: Handle; VAR refNum: ResFileRefNum): OSStatus; C;
  374. FUNCTION RMAddResource(theData: Handle; theType: ResType; theID: ResID; name: Str255): OSStatus; C;
  375. FUNCTION RMRemoveResource(theResource: Handle): OSStatus; C;
  376. FUNCTION RMCountTypes(oneDeep: BOOLEAN; VAR count: UInt32): OSStatus; C;
  377. FUNCTION RMGetIndexedType(index: UInt32; oneDeep: BOOLEAN; VAR theType: ResType): OSStatus; C;
  378. FUNCTION RMCountResources(theType: ResType; oneDeep: BOOLEAN; VAR count: UInt32): OSStatus; C;
  379. FUNCTION RMGetIndexedResource(theType: ResType; index: UInt32; oneDeep: BOOLEAN; resLoad: BOOLEAN; VAR handle: Handle): OSStatus; C;
  380. FUNCTION RMGetResource(theType: ResType; theID: ResID; oneDeep: BOOLEAN; resLoad: BOOLEAN; VAR handle: Handle): OSStatus; C;
  381. FUNCTION RMGetNamedResource(theType: ResType; name: Str255; oneDeep: BOOLEAN; resLoad: BOOLEAN; VAR handle: Handle): OSStatus; C;
  382. FUNCTION RMLoadResource(theResource: Handle): OSStatus; C;
  383. FUNCTION RMReleaseResource(theResource: Handle): OSStatus; C;
  384. FUNCTION RMDetachResource(theResource: Handle): OSStatus; C;
  385. FUNCTION RMChangedResource(theResource: Handle): OSStatus; C;
  386. FUNCTION RMWriteResource(theResource: Handle): OSStatus; C;
  387. FUNCTION RMSetResourceSize(theResource: Handle; newSize: SInt32): OSStatus; C;
  388. FUNCTION RMUniqueID(theType: ResType; oneDeep: BOOLEAN; VAR idPtr: ResID): OSStatus; C;
  389. FUNCTION RMGetResAttributes(theResource: Handle; VAR attributes: ResAttributes): OSStatus; C;
  390. FUNCTION RMGetResInfo(theResource: Handle; VAR typePtr: ResType; VAR idPtr: ResID; VAR name: Str255): OSStatus; C;
  391. FUNCTION RMSetResInfo(theResource: Handle; theType: ResType; theID: ResID; name: Str255): OSStatus; C;
  392. FUNCTION RMSetResAttributes(theResource: Handle; attrs: ResAttributes): OSStatus; C;
  393. FUNCTION RMReadPartialResource(theResource: Handle; offset: UInt32; buffer: UNIV Ptr; count: UInt32): OSStatus; C;
  394. FUNCTION RMWritePartialResource(theResource: Handle; offset: UInt32; buffer: UNIV Ptr; count: UInt32): OSStatus; C;
  395. {
  396.  * GetResourceSize returns either the size of the handle if the handle
  397.  * is not empty or the size of the resource as stored on disk (i.e.
  398.  * it has the exact semantics of GetResourceSizeOnDisk but does not
  399.  * have the confusing name).
  400. }
  401. FUNCTION RMGetResourceSize(theResource: Handle; VAR size: SInt32): OSStatus; C;
  402. FUNCTION RMSetResErrProc(proc: ResErrUPP): OSStatus; C;
  403. {
  404.  *    For now, we don't know if we want to support the purge
  405.  *    proc in the future... it's an outstanding issue as stated in the
  406.  *    Design Document.
  407.  *
  408.  *    OSStatus RMSetResPurge(Boolean install);
  409. }
  410. {
  411.  *    The following calls are used to get/set the read only state (i.e. the
  412.  *    mapReadOnly file attribute) of a resource file.  When setting the state,
  413.  *  the state is set both in memory (i.e. taking affect immediately for all
  414.  *    other calls) and on disk (i.e. next time the file is opened, it will
  415.  *    be opened with the read only state set).  The call RMSetResFileReadOnlyState
  416.  *    ignores the current state of the resource file.  Setting the read only
  417.  *    state changes the current resource file attributes of the file both
  418.  *    in memory and on disk as appropriately (i.e. setting/clearing the read only state
  419.  *    will set/clear the mapReadOnly bit in memory and on disk).
  420.  *
  421.  *    The read only state is checked when .... [this needs to be filled in -- it
  422.  *    will be exactly the same as when the mapReadOnly bit is checked].
  423. }
  424. FUNCTION RMSetResFileReadOnlyState(refNum: ResFileRefNum; isReadOnly: BOOLEAN): OSStatus; C;
  425. FUNCTION RMGetResFileReadOnlyState(refNum: ResFileRefNum; VAR isReadOnly: BOOLEAN): OSStatus; C;
  426. {$ENDC}
  427. {$ALIGN RESET}
  428. {$POP}
  429.  
  430. {$SETC UsingIncludes := ResourcesIncludes}
  431.  
  432. {$ENDC} {__RESOURCES__}
  433.  
  434. {$IFC NOT UsingIncludes}
  435.  END.
  436. {$ENDC}
  437.